/**
 * qiankun 环境判断工具类（子应用版本）
 * 统一管理所有与 qiankun 相关的环境判断逻辑
 */

import { qiankunWindow } from 'vite-plugin-qiankun/dist/helper'

// 缓存检测结果，避免重复计算
let cache = {
    isSubApp: null,
    isMainApp: null,
    appType: null,
    subAppName: null,
    props: null
}

// 重置缓存
export const resetCache = () => {
    cache = {
        isSubApp: null,
        isMainApp: null,
        appType: null,
        subAppName: null,
        props: null
    }
}

/**
 * 判断是否为子应用环境
 * 使用多重检测策略确保准确性
 */
export const isSubApp = () => {
    if (cache.isSubApp !== null) {
        return cache.isSubApp
    }

    try {
        // 方法1: 检查 qiankun 特有的 window 变量
        const method1 = !!(window.__POWERED_BY_QIANKUN__ || window.__INJECTED_PUBLIC_PATH_BY_QIANKUN__)
        
        // 方法2: 通过 vite-plugin-qiankun 检查
        const method2 = !!(qiankunWindow && qiankunWindow.__POWERED_BY_QIANKUN__)
        
        // 方法3: 检查窗口层级（是否在 iframe 中）
        const method3 = window.self !== window.top
        
        // 方法4: 检查 URL 特征
        const method4 = window.location.pathname.includes('/sub-app')
        
        // 综合判断：至少两个方法返回 true
        const result = [method1, method2, method3, method4].filter(Boolean).length >= 2
        
        cache.isSubApp = result
        return result
    } catch (error) {
        console.warn('[环境检测] isSubApp 检测异常:', error)
        cache.isSubApp = false
        return false
    }
}

/**
 * 判断是否为主应用环境
 */
export const isMainApp = () => {
    if (cache.isMainApp !== null) {
        return cache.isMainApp
    }

    try {
        const result = !isSubApp() && window.self === window.top
        cache.isMainApp = result
        return result
    } catch (error) {
        console.warn('[环境检测] isMainApp 检测异常:', error)
        cache.isMainApp = false
        return false
    }
}

/**
 * 获取应用类型
 */
export const getAppType = () => {
    if (cache.appType !== null) {
        return cache.appType
    }

    if (isSubApp()) {
        cache.appType = 'sub'
    } else if (isMainApp()) {
        cache.appType = 'main'
    } else {
        cache.appType = 'unknown'
    }

    return cache.appType
}

/**
 * 获取子应用名称
 */
export const getSubAppName = () => {
    if (cache.subAppName !== null) {
        return cache.subAppName
    }

    if (!isSubApp()) {
        cache.subAppName = null
        return null
    }

    try {
        // 从 URL 路径中提取子应用名称
        const pathname = window.location.pathname
        const match = pathname.match(/\/(sub-app\d+)/)
        
        if (match) {
            cache.subAppName = match[1]
            return match[1]
        }

        cache.subAppName = 'unknown-sub-app'
        return 'unknown-sub-app'
    } catch (error) {
        console.warn('[环境检测] getSubAppName 检测异常:', error)
        cache.subAppName = null
        return null
    }
}

/**
 * 获取路由模式
 */
export const getRouterMode = () => {
    return isSubApp() ? 'memory' : 'history'
}

// ========== 新增：主应用数据接收和处理 ==========

// 存储主应用传递的 props
let mainAppProps = null

/**
 * 设置主应用传递的 props
 * 这个函数会在子应用的 main.js 中被调用
 */
export const setMainAppProps = (props) => {
    mainAppProps = props
    console.log('[子应用] 接收到主应用 props:', props)
    
    // 如果有全局状态管理器，设置监听
    if (props && props.actions) {
        setupGlobalStateListener(props.actions)
    }
}

/**
 * 获取主应用传递的 props
 */
export const getMainAppProps = () => {
    return mainAppProps
}

/**
 * 获取全局状态管理器
 */
export const getGlobalActions = () => {
    return mainAppProps?.actions || null
}

/**
 * 获取主应用数据管理器
 */
export const getMainAppData = () => {
    return mainAppProps?.mainAppData || null
}

/**
 * 子应用数据管理器
 */
export const subAppData = {
    // 向主应用发送数据
    sendToMain(data) {
        const actions = getGlobalActions()
        if (actions) {
            actions.setGlobalState(data)
            console.log('[子应用] 向主应用发送数据:', data)
        } else {
            console.warn('[子应用] 无法向主应用发送数据，actions 不存在')
        }
    },

    // 更新用户信息到主应用
    updateUser(userInfo) {
        const mainAppData = getMainAppData()
        if (mainAppData) {
            mainAppData.setUser(userInfo)
            console.log('[子应用] 更新用户信息到主应用:', userInfo)
        } else {
            console.warn('[子应用] 无法更新用户信息，mainAppData 不存在')
        }
    },

    // 切换主题
    switchTheme(theme) {
        const mainAppData = getMainAppData()
        if (mainAppData) {
            mainAppData.setTheme(theme)
            console.log('[子应用] 切换主题:', theme)
        } else {
            console.warn('[子应用] 无法切换主题，mainAppData 不存在')
        }
    },

    // 发送通知
    sendNotification(notification) {
        const mainAppData = getMainAppData()
        if (mainAppData) {
            mainAppData.sendNotification({
                from: getSubAppName(),
                ...notification
            })
            console.log('[子应用] 发送通知:', notification)
        } else {
            console.warn('[子应用] 无法发送通知，mainAppData 不存在')
        }
    },

    // 更新共享数据
    updateSharedData(data) {
        const mainAppData = getMainAppData()
        if (mainAppData) {
            mainAppData.updateSharedData({
                [`${getSubAppName()}`]: data
            })
            console.log('[子应用] 更新共享数据:', data)
        } else {
            console.warn('[子应用] 无法更新共享数据，mainAppData 不存在')
        }
    },

    // 获取全局状态
    getGlobalState() {
        const actions = getGlobalActions()
        if (actions && typeof actions.getGlobalState === 'function') {
            try {
                return actions.getGlobalState()
            } catch (error) {
                console.warn('[子应用] 调用getGlobalState失败:', error)
                return null
            }
        }
        
        // 如果没有getGlobalState方法，尝试其他方式获取状态
        if (actions && actions.state) {
            return actions.state
        }
        
        console.warn('[子应用] 无法获取全局状态，actions或getGlobalState方法不存在')
        return null
    },

    // 跳转主应用路由
    navigateToMain(path) {
        const props = getMainAppProps()
        if (props && props.setMainAppRoute) {
            props.setMainAppRoute(path)
            console.log('[子应用] 跳转主应用路由:', path)
        } else {
            console.warn('[子应用] 无法跳转主应用路由，setMainAppRoute 不存在')
        }
    },

    // 使用主应用工具函数
    showMessage(message, type = 'info') {
        const props = getMainAppProps()
        if (props && props.utils && props.utils.showMessage) {
            props.utils.showMessage(message, type)
        } else {
            console.log(`[子应用消息-${type}]:`, message)
        }
    },

    async showConfirm(message) {
        const props = getMainAppProps()
        if (props && props.utils && props.utils.showConfirm) {
            return await props.utils.showConfirm(message)
        } else {
            return confirm(message)
        }
    }
}

// 全局状态监听器
let globalStateListener = null

/**
 * 设置全局状态监听
 */
const setupGlobalStateListener = (actions) => {
    if (globalStateListener) {
        // 如果已经有监听器，先取消
        return
    }

    globalStateListener = actions.onGlobalStateChange((state, prev) => {
        console.log('[子应用] 全局状态变化:', { state, prev })
        
        // 可以在这里处理特定的状态变化
        if (state.user !== prev.user) {
            console.log('[子应用] 用户信息变化:', state.user)
            // 触发自定义事件
            window.dispatchEvent(new CustomEvent('userChanged', { 
                detail: state.user 
            }))
        }

        if (state.theme !== prev.theme) {
            console.log('[子应用] 主题变化:', state.theme)
            // 触发自定义事件
            window.dispatchEvent(new CustomEvent('themeChanged', { 
                detail: state.theme 
            }))
        }

        if (state.sharedData?.notifications !== prev.sharedData?.notifications) {
            console.log('[子应用] 收到新通知:', state.sharedData?.notifications)
            // 触发自定义事件
            window.dispatchEvent(new CustomEvent('notificationReceived', { 
                detail: state.sharedData?.notifications 
            }))
        }
    })
}

/**
 * Vue 3 组合式函数
 */
export const useQiankun = () => {
    const appType = getAppType()
    const subAppName = getSubAppName()
    const routerMode = getRouterMode()
    const props = getMainAppProps()

    // 安全获取全局状态
    const getGlobalStateSafely = () => {
        try {
            return subAppData.getGlobalState()
        } catch (error) {
            console.warn('[子应用] 获取全局状态失败:', error)
            return null
        }
    }

    return {
        isSubApp: isSubApp(),
        isMainApp: isMainApp(),
        appType,
        subAppName,
        routerMode,
        props,
        // 数据管理
        subAppData,
        // 全局状态 - 使用安全获取方法
        globalState: getGlobalStateSafely(),
        // 工具函数
        showMessage: subAppData.showMessage,
        showConfirm: subAppData.showConfirm,
        navigateToMain: subAppData.navigateToMain,
        // 提供安全的获取全局状态方法
        getGlobalState: getGlobalStateSafely
    }
}

// 调试模式
export const enableDebugMode = () => {
    window.__QIANKUN_DEBUG__ = true
    console.log('[qiankun 工具] 调试模式已开启')
    console.log('环境信息:', {
        isSubApp: isSubApp(),
        isMainApp: isMainApp(),
        appType: getAppType(),
        subAppName: getSubAppName(),
        routerMode: getRouterMode(),
        props: getMainAppProps()
    })
} 